
class Persons{//因为在demo2中存在Person的类 所以我们创建一个新的类Persons
    private String name;
//    通过封装可以使我们的属性更加安全
//    这样就不能通过persons.name修改内容了 所以我们可以通过这两种方法
//    1.赋值
//    public void setName(String myName){
//        name = myName;
//    }
////    2.查看
//    public String getName(){
//        return name;
//    }




    public static int count = 10;
    {
//        this.age = 18;
        System.out.println("实例代码块");
    }
    static {
        count = 99;
        System.out.println("静态代码块");
    }

//    main4 打印count的值  看count = 99; 和   public static int count = 10; 的顺序有关
//    哪个顺序靠后 就会打印哪个  但是如果public static int count没有初始化又放在static{}后面 那么打印的默认值是count = 99;





    private int age;
    //    1.赋值
//    public void setAge(int age){//这一行的age属于局部变量
////        age = age;//在大括号里面 局部变量会优先使用  我们所创建private int age 的age没有被使用
//        this.age = age;
////        所以我们可以怎么解决呢  在第一个age前+this.     this代表当前对象的引用
//    }
//    //    2.查看
//    public int getAge(){
//        return age;
//    }

//    这里有个问题 如果我们创建类里面的属性太多  是不是每次都需要自己打set get方法   回答不用
//    我们可以通过 鼠标右键-》Generate -》Getter and Setter-》选择自己需要的属性-》点OK  这样就可以一键生成了
//    先把上面的注释掉



    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Persons{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }


    //    构造方法
//    方法名和类名是相同的 且构造方法比较特殊 没有返回值
//    构造方法是做什么的？ 一个对象的产生[对象的实例化]▲
//    1.为对象分配内存
//    2.调用合适（构造方法不止一个）的构造方法

    public  Persons(){//public 不能改成private 如果改了 外面的Persons persons = new Persons() 的 Persons()就会报错
        this("lik");//调用带有一个参数的构造方法 这个this()必须放到第一行 所以不能出现多个this()
        System.out.println("Persons()::不带参数的构造方法");
    }

//    1.如果我们没有实现任何的构造方法 编译器会帮我们默认生成一个不带参数的构造方法
//    2.(注意 当我们有生成带参数的方法时 编译器将不在生成不带参数的构造方法 下面代码的Persons()就会报错)
//    3.构造方法之间可以构成重载
//    一个类 一个类至少有一个构造方法
//    public Persons(){
//    }

    public Persons(String name){
        this.name = name;//this代表当前对象的引用       有些书会说this代表当前对象这是err的
        System.out.println("Persons(String name)带一个String类型参数的构造方法");
    }
    public Persons(String name, int age){
        this.name = name;
        this.age = age;
        System.out.println("Persons(String int)带两个参数的构造方法");
    }

//    这三个构造方法构成了重载
//    1.方法名称相同
//    2.参数列表不同
//    3.返回值不做要求





    public void eat() {
        System.out.println(name + "正在吃饭");
    }
    public void sleep() {
        System.out.println(name + "正在睡觉");
    }
    public void print(){
        //调用当前对象的eat方法
        this.eat();
        this.sleep();
    }

}

//面试问题：this和super有什么区别
//this：
//1.this.name     调用当前对象的属性90行
//2.this.func()   调用当前对象的方法112行 152行
//3.this()        调用当前对象的其他构造方法  这里表示是调用不带参数的构造方法  ▲this只能存放在构造函数中




public class Demo3 {
    public static void main1(String[] args) {
        Persons persons = new Persons();
        System.out.println(persons);


        persons.setName("lcw");
        System.out.println(persons.getName());
        persons.setAge(18);
        System.out.println(persons.getAge());//为什么这里结果还是为0呢 第19行
    }



//    构造方法使用
    public static void main2(String[] args) {
        System.out.println("========调用不带参数的构造方法=========");
//        Persons persons = new Persons();//输出结果  Persons()::不带参数的构造方法   Persons()这个表示调用了不带参数的构造方法
        System.out.println("========调用带一个参数的构造方法=========");
        Persons persons1 = new Persons("lcw");
        System.out.println("========调用带两个参数的构造方法=========");
        Persons persons2 = new Persons("lcw",18);
        System.out.println("========调用当前对象的eat方法=========");
        persons2.print();
        System.out.println("========调用带this()的构造方法=========");//80h
        Persons persons3 = new Persons();//在public  Persons()内加上this("lik")后  不能没有参数 不然就一直调用了
        System.out.println(persons3);//此时name就有值了
    }







//    代码块：
//    1.本地代码块
//    ▲2.实例代码块20h
//    ▲3.静态代码块23h
//    4.同步代码块
    public static void main3(String[] args) {

        {
//            System.out.println("这个是本地代码块");
        }

        Persons persons1 = new Persons();
//        打印结果是
//                  静态代码块
//                  实例代码块
//                  Persons(String name)带一个String类型参数的构造方法
//                  Persons()::不带参数的构造方法
        System.out.println("====================");
        Persons persons2 = new Persons();
//        打印结果是
//                  实例代码块
//                  Persons(String name)带一个String类型参数的构造方法
//                  Persons()::不带参数的构造方法

//        静态-》实例-》构造   打印顺序
//        此时发现静态代码块没有被打印 静态代码块只能被执行一次（和你new多少对象没有关系）
    }


    public static void main4(String[] args) {
        System.out.println(Persons.count);
        System.out.println(Persons.count);
//        运行结果是：
//              静态代码块
//              0
//              0
//        静态代码块只被执行一次
    }



//    toString
//    序列化：对象 转为 字符串
//    反序列化：字符串 转为 对象


//    匿名对象
//    没有引用的对象称为匿名对象.
//    匿名对象只能在创建对象时使用.如果一个对象只是用一次,
//    后面不需要用了, 可以考虑使用匿名对象.
    public static void main(String[] args) {
        new Persons().eat();//每次调用只能使用一次
        new Persons().sleep();
        System.out.println("====================");

    }





}



